package br.com.testeoab.dao;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import au.com.bytecode.opencsv.CSVReader;
import br.com.testeoab.model.AlternativaCorreta;
import br.com.testeoab.model.Alternativas;
import br.com.testeoab.model.Materia;
import br.com.testeoab.model.Perguntas;

public class TesteOABHelper extends SQLiteOpenHelper {

	@SuppressWarnings("unused")
	private SQLiteDatabase database;

	private Context context;
	private Perguntas clsPergunta = new Perguntas();
	private List<Perguntas> clsPerguntas = new ArrayList<Perguntas>();
	private Materia clsMateria = new Materia();
	private List<Materia> clsMaterias = new ArrayList<Materia>();
	private Alternativas clsAlternativa = new Alternativas();
	private List<Alternativas> clsAlternativas = new ArrayList<Alternativas>();
	private AlternativaCorreta clsAlternativaCorreta = new AlternativaCorreta();
	private List<AlternativaCorreta> clsAlternativaCorretas = new ArrayList<AlternativaCorreta>();

	private static final int DATABASE_VERSION = 2;
	private static final String DATABASE = "testeOAB";

	// materia
	private static final String MATERIA_TABLE_NAME = "tblMaterias";
	private static final String MATERIA_COLUNNS_ID = "id_materia";
	private static final String MATERIA_COLUNNS_NOME = "nome";

	// perguntas
	private static final String PERGUNTAS_TABLE_NAME = "tblPerguntas";
	private static final String PERGUNTAS_COLUNNS_ID = "id_pergunta";
	private static final String PERGUNTAS_COLUNNS_PERGUNTA = "pergunta";
	private static final String PERGUNTAS_COLUNNS_ID_MATERIA = "id_materia";

	// alternativas
	private static final String ALTERNATIVAS_TABLE_NAME = "tblAlternativas";
	private static final String ALTERNATIVAS_COLUNNS_ID = "id_Alternativa";
	private static final String ALTERNATIVAS_COLUNNS_ALTERNATIVA = "Alternativa";
	private static final String ALTERNATIVAS_COLUNNS_ID_PERGUNTA = "id_pergunta";

	// alternativa correta
	private static final String ALTERNATIVA_CORRETA_TABLE_NAME = "tblAlternativa_correta";
	private static final String ALTERNATIVA_CORRETA_COLUNNS_ID = "id_Alternativa_correta";
	private static final String ALTERNATIVA_CORRETA_COLUNNS_ID_PERGUNTA = "id_pergunta";
	private static final String ALTERNATIVA_CORRETA_COLUNNS_ID_ALTERNATIVA = "id_Alternativa";

	// create tables query's
	private static final String MATERIA_CREATE_TABLE = "CREATE TABLE IF NOT EXISTS "
			+ MATERIA_TABLE_NAME
			+ " ("
			+ MATERIA_COLUNNS_ID
			+ " INTEGER PRIMARY KEY, "
			+ MATERIA_COLUNNS_NOME
			+ " TEXT  NOT NULL);";

	private static final String PERGUNTAS_CREATE_TABLE = "CREATE TABLE IF NOT EXISTS "
			+ PERGUNTAS_TABLE_NAME
			+ " ("
			+ PERGUNTAS_COLUNNS_ID
			+ " INTEGER PRIMARY KEY, "
			+ PERGUNTAS_COLUNNS_PERGUNTA
			+ " TEXT NOT NULL, "
			+ PERGUNTAS_COLUNNS_ID_MATERIA
			+ " INTEGER NOT NULL, "
			+ " FOREIGN KEY("
			+ PERGUNTAS_COLUNNS_ID_MATERIA
			+ ") REFERENCES "
			+ MATERIA_TABLE_NAME + "(" + MATERIA_COLUNNS_ID + "));";

	private static final String ALTERNATIVAS_CREATE_TABLE = "CREATE TABLE IF NOT EXISTS "
			+ ALTERNATIVAS_TABLE_NAME
			+ " ("
			+ ALTERNATIVAS_COLUNNS_ID
			+ " INTEGER PRIMARY KEY, "
			+ ALTERNATIVAS_COLUNNS_ALTERNATIVA
			+ " TEXT NOT NULL, "
			+ ALTERNATIVAS_COLUNNS_ID_PERGUNTA
			+ " INTEGER NOT NULL, "
			+ " FOREIGN KEY( "
			+ ALTERNATIVAS_COLUNNS_ID_PERGUNTA
			+ ") REFERENCES "
			+ PERGUNTAS_TABLE_NAME + "(" + PERGUNTAS_COLUNNS_ID + "));";

	private static final String CREATE_ALTERNATIVA_CORRETA_TABLE = "CREATE TABLE IF NOT EXISTS "
			+ ALTERNATIVA_CORRETA_TABLE_NAME
			+ " ( "
			+ ALTERNATIVA_CORRETA_COLUNNS_ID
			+ " INTEGER PRIMARY KEY, "
			+ ALTERNATIVA_CORRETA_COLUNNS_ID_PERGUNTA
			+ " INTEGER NOT NULL, "
			+ ALTERNATIVA_CORRETA_COLUNNS_ID_ALTERNATIVA
			+ " INTEGER NOT NULL, "
			+ " FOREIGN KEY( "
			+ ALTERNATIVA_CORRETA_COLUNNS_ID_PERGUNTA
			+ ") REFERENCES "
			+ PERGUNTAS_TABLE_NAME
			+ "("
			+ PERGUNTAS_COLUNNS_ID
			+ "),"
			+ " FOREIGN KEY( "
			+ ALTERNATIVA_CORRETA_COLUNNS_ID_ALTERNATIVA
			+ ") REFERENCES "
			+ ALTERNATIVAS_TABLE_NAME
			+ "("
			+ ALTERNATIVAS_COLUNNS_ID + "));";

	public TesteOABHelper(Context context) {
		super(context, DATABASE, null, DATABASE_VERSION);
		this.context = context;
	}

	public void open() throws SQLException { // chama o onCreate
		database = this.getWritableDatabase();
	}

	@Override
	public void onCreate(SQLiteDatabase db) {
		// TODO Auto-generated method stub

		String sqlMaterias = MATERIA_CREATE_TABLE;
		db.execSQL(sqlMaterias);

		String sqlPerguntas = PERGUNTAS_CREATE_TABLE;
		db.execSQL(sqlPerguntas);

		String sqlAlternativas = ALTERNATIVAS_CREATE_TABLE;
		db.execSQL(sqlAlternativas);

		String sqlAlternativaCorreta = CREATE_ALTERNATIVA_CORRETA_TABLE;
		db.execSQL(sqlAlternativaCorreta);

		populaMateria(db);
		populaPerguntas(db);
		populaAlternativas(db);
		populaAlternativaCorreta(db);
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
		// TODO Auto-generated method stub

	}

	private void populaMateria(SQLiteDatabase db) {

		try {

			CSVReader reader = new CSVReader(new InputStreamReader(context
					.getAssets().open("materia.csv")));
			String[] nextLine;

			while ((nextLine = reader.readNext()) != null) {
				clsMateria = new Materia();
				clsMateria.setLngId(Long.getLong(nextLine[0]));
				clsMateria.setStrMateria(nextLine[1]);
				clsMaterias.add(clsMateria);
			}
			insertMateria(clsMaterias, db);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void populaPerguntas(SQLiteDatabase db) {

		try {

			CSVReader reader = new CSVReader(new InputStreamReader(context
					.getAssets().open("perguntas.csv")));
			String[] nextLine;

			while ((nextLine = reader.readNext()) != null) {
				clsPergunta = new Perguntas();
				clsPergunta.setLngId(Long.getLong(nextLine[0]));
				clsPergunta.setStrPergunta(nextLine[1]);
				clsPergunta.setIntIdMateria(Integer.parseInt(nextLine[2]));

				clsPerguntas.add(clsPergunta);
			}
			insertPerguntas(clsPerguntas, db);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void populaAlternativas(SQLiteDatabase db) {

		try {

			CSVReader reader = new CSVReader(new InputStreamReader(context
					.getAssets().open("alternativas.csv")));
			String[] nextLine;

			while ((nextLine = reader.readNext()) != null) {
				clsAlternativa = new Alternativas();
				// clsAlternativa.setLngId(Long.getLong(nextLine[0]));
				clsAlternativa.setStrAlternativa(nextLine[1]);
				clsAlternativa.setIntIdPergunta(Integer.parseInt(nextLine[2]));

				clsAlternativas.add(clsAlternativa);
			}
			insertAlternativa(clsAlternativas, db);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void insertAlternativa(List<Alternativas> clsAlternativas,
			SQLiteDatabase db) {

		for (int i = 0; i < clsAlternativas.size(); i++) {

			clsAlternativa = new Alternativas();
			clsAlternativa = clsAlternativas.get(i);
			ContentValues values = new ContentValues();
			values.put(ALTERNATIVAS_COLUNNS_ALTERNATIVA,
					clsAlternativa.getStrAlternativa());
			values.put(ALTERNATIVAS_COLUNNS_ID_PERGUNTA,
					clsAlternativa.getIntIdPergunta());

			db.insert(ALTERNATIVAS_TABLE_NAME, null, values);
		}
	}

	private void populaAlternativaCorreta(SQLiteDatabase db) {

		try {

			CSVReader reader = new CSVReader(new InputStreamReader(context
					.getAssets().open("alternativaCorreta.csv")));
			String[] nextLine;

			while ((nextLine = reader.readNext()) != null) {
				clsAlternativaCorreta = new AlternativaCorreta();
				// clsAlternativaCorreta.setLngId(Long.getLong(nextLine[0]));
				clsAlternativaCorreta.setIntIdPergunta(Integer
						.parseInt(nextLine[1]));
				clsAlternativaCorreta.setIntIdAlternativa(Integer
						.parseInt(nextLine[2]));

				clsAlternativaCorretas.add(clsAlternativaCorreta);
			}
			insertAlternativaCorreta(clsAlternativaCorretas, db);

		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	private void insertAlternativaCorreta(
			List<AlternativaCorreta> clsAlternativaCorretas, SQLiteDatabase db) {

		for (int i = 0; i < clsAlternativaCorretas.size(); i++) {

			clsAlternativaCorreta = new AlternativaCorreta();
			clsAlternativaCorreta = clsAlternativaCorretas.get(i);
			ContentValues values = new ContentValues();
			values.put(ALTERNATIVA_CORRETA_COLUNNS_ID_PERGUNTA,
					clsAlternativaCorreta.getIntIdPergunta());
			values.put(ALTERNATIVA_CORRETA_COLUNNS_ID_ALTERNATIVA,
					clsAlternativaCorreta.getIntIdAlternativa());

			db.insert(ALTERNATIVA_CORRETA_TABLE_NAME, null, values);
		}
	}

	private void insertPerguntas(List<Perguntas> clsPerguntas, SQLiteDatabase db) {

		for (int i = 0; i < clsPerguntas.size(); i++) {
			clsPergunta = new Perguntas();
			clsPergunta = clsPerguntas.get(i);
			ContentValues values = new ContentValues();
			values.put(PERGUNTAS_COLUNNS_PERGUNTA, clsPergunta.getStrPergunta());
			values.put(PERGUNTAS_COLUNNS_ID_MATERIA,
					clsPergunta.getIntIdMateria());

			db.insert(PERGUNTAS_TABLE_NAME, null, values);
		}
	}

	private void insertMateria(List<Materia> clsMaterias, SQLiteDatabase db) {

		for (int i = 0; i < clsMaterias.size(); i++) {
			clsMateria = new Materia();
			clsMateria = clsMaterias.get(i);
			ContentValues values = new ContentValues();
			values.put(MATERIA_COLUNNS_NOME, clsMateria.getStrMateria());
			db.insert(MATERIA_TABLE_NAME, null, values);
		}
	}

	public Perguntas getPerguntaById(int intID) {
		Perguntas clsPergunta = new Perguntas();

		StringBuilder strSql = new StringBuilder();
		strSql.append(" select * from " + PERGUNTAS_TABLE_NAME);
		strSql.append(" WHERE " + PERGUNTAS_COLUNNS_ID + " = " + intID);

		Cursor c = getWritableDatabase().rawQuery(strSql.toString(), null);

		while (c.moveToNext()) {
			clsPergunta = new Perguntas();

			clsPergunta.setLngId(c.getLong(0));
			clsPergunta.setStrPergunta(c.getString(1));
			clsPergunta.setStrMateria(c.getString(2));
		}

		return clsPergunta;
	}

	public List<Alternativas> getAlternativasByPergunta(int intIdPergunta) {

		clsAlternativas = new ArrayList<Alternativas>();

		StringBuilder strSql = new StringBuilder();
		strSql.append(" SELECT * FROM " + ALTERNATIVAS_TABLE_NAME);
		strSql.append(" WHERE " + ALTERNATIVAS_COLUNNS_ID_PERGUNTA + " = "
				+ intIdPergunta);

		Cursor c = getWritableDatabase().rawQuery(strSql.toString(), null);

		while (c.moveToNext()) {
			clsAlternativa = new Alternativas();
			clsAlternativa.setLngId(c.getLong(0));
			clsAlternativa.setStrAlternativa(c.getString(1));
			clsAlternativas.add(clsAlternativa);
		}
		return clsAlternativas;
	}

	public AlternativaCorreta getAlternativaCorretaByPergunta(int intIdPergunta) {

		clsAlternativaCorreta = new AlternativaCorreta();

		StringBuilder strSql = new StringBuilder();
		strSql.append("SELECT * FROM " + ALTERNATIVA_CORRETA_TABLE_NAME);
		strSql.append(" WHERE " + ALTERNATIVA_CORRETA_COLUNNS_ID_PERGUNTA + " = " + intIdPergunta);

		Cursor c = getWritableDatabase().rawQuery(strSql.toString(), null);

		while (c.moveToNext()) {
			clsAlternativaCorreta.setIntIdAlternativa(c.getInt(2));
		}

		return clsAlternativaCorreta;
	}

}
